home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Mark Pilgrim / Shutdown FX 2.1 / source / sfx control app ƒ / Shell ƒ / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  8.3 KB  |  332 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        menus.c
  4.  
  5. Purpose:    This module handles menu selections.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program in a file named "GNU General Public License".
  19. If not, write to the Free Software Foundation, 675 Mass Ave,
  20. Cambridge, MA 02139, USA.
  21.  
  22. \**********************************************************************/
  23.  
  24. #include "graphics.h"
  25. #include "menus.h"
  26. #include "help.h"
  27. #include "environment.h"
  28. #include "error.h"
  29. #include "dialogs.h"
  30. #include "file interface.h"
  31. #include "debinhex dispatch.h"
  32. #include "file management.h"
  33. #include "program globals.h"
  34. #include "sfx main window.h"
  35.  
  36. MenuHandle        gAppleMenu;
  37. MenuHandle        gFileMenu;
  38. MenuHandle        gEditMenu;
  39. MenuHandle        gOptionsMenu;
  40.  
  41. enum
  42. {
  43.     appleMenu = 400, fileMenu, editMenu, optionsMenu,
  44.     
  45.     aboutItem = 1, aboutMSGItem, helpPointerItem,
  46.     
  47.     openItem=1, closeItem, file_unused1, deBinHexItem, file_unused2,
  48.         quitItem,
  49.     
  50.     undoItem = 1, cutItem = 3, copyItem, pasteItem, clearItem, selectAllItem,
  51.     
  52.     kRestartOnly=1, kShutdownOnly, kRestartAndShutdown, kNever, options_unused1,
  53.         kPickRandom, kPickSequential, options_unused2, kFadeEarly, kFadeLate,
  54.         options_unused3, kRescanForModules
  55. };
  56.  
  57. /*-----------------------------------------------------------------------------------*/
  58. /* internal stuff for menus.c                                                        */
  59.  
  60. static void HandleAppleMenu(short menuItem);
  61. static void HandleFileMenu(short menuItem);
  62. static void HandleEditMenu(short menuItem);
  63. static void HandleHelpMenu(void);
  64. static void HandleOptionsMenu(short menuItem);
  65. static void ChangeWarning(void);
  66.  
  67. Boolean InitTheMenus(void)
  68. {
  69.     Handle        MBARHandle;
  70.     
  71.     if ((MBARHandle=GetNewMBar(400))==0L)        /* sez which menus are in menu bar. */
  72.         return FALSE;
  73.     SetMenuBar(MBARHandle);                        /* set this to be THE menu bar to use. */
  74.     
  75.     if ((gAppleMenu=GetMHandle(appleMenu))==0L)    /* GetNewMBar also got menu handles of */
  76.         return FALSE;
  77.     if ((gFileMenu=GetMHandle(fileMenu))==0L)    /* every menu it includes, so just */
  78.         return FALSE;
  79.     if ((gEditMenu=GetMHandle(editMenu))==0L)    /* grab these handles and assign them */
  80.         return FALSE;
  81.     if ((gOptionsMenu=GetMHandle(optionsMenu))==0L)
  82.         return FALSE;
  83.         
  84.     AddResMenu(gAppleMenu, 'DRVR');                /* adds control panels to apple menu */
  85.     
  86.     AdjustMenus();                                /* dim/enable/check/mark menus/items */
  87.     DrawMenuBar();                                /* draws the actual menu bar */
  88.     
  89.     return TRUE;
  90. }
  91.  
  92. void AdjustMenus(void)
  93. {
  94.     WindowPeek        theWindow;
  95.     short            kind;
  96.     
  97.     if (gInProgress)
  98.     {
  99.         DisableItem(gAppleMenu, aboutItem);
  100.         DisableItem(gAppleMenu, aboutMSGItem);
  101.         DisableItem(gAppleMenu, helpPointerItem);
  102.         DisableItem(gFileMenu, 0);
  103.         DisableItem(gEditMenu, 0);
  104.         DisableItem(gOptionsMenu, 0);
  105.     }
  106.     else
  107.     {
  108.         EnableItem(gAppleMenu, aboutItem);
  109.         EnableItem(gAppleMenu, aboutMSGItem);
  110.         EnableItem(gAppleMenu, helpPointerItem);
  111.         EnableItem(gFileMenu, 0);
  112.         EnableItem(gEditMenu, 0);
  113.         EnableItem(gOptionsMenu, 0);
  114.         
  115.         theWindow = (WindowPeek)FrontWindow();
  116.         kind = theWindow ? theWindow->windowKind : 0;
  117.         
  118.         if (kind < 0)
  119.         {
  120.             EnableItem(gEditMenu, undoItem);
  121.             EnableItem(gEditMenu, cutItem);
  122.             EnableItem(gEditMenu, copyItem);
  123.             EnableItem(gEditMenu, pasteItem);
  124.             EnableItem(gEditMenu, clearItem);
  125.         }
  126.         else
  127.         {
  128.             DisableItem(gEditMenu, undoItem);
  129.             DisableItem(gEditMenu, cutItem);
  130.             DisableItem(gEditMenu, copyItem);
  131.             DisableItem(gEditMenu, pasteItem);
  132.             DisableItem(gEditMenu, clearItem);
  133.         }
  134.         
  135.         if(theWindow)
  136.             EnableItem(gFileMenu, closeItem);
  137.         else
  138.             DisableItem(gFileMenu, closeItem);
  139.         
  140.         if (GetIndWindowGrafPtr(kMainWindow))
  141.             DisableItem(gFileMenu, openItem);
  142.         else
  143.             EnableItem(gFileMenu, openItem);
  144.     }
  145.     
  146.     CheckItem(gOptionsMenu, kRestartOnly, gOnRestart && !gOnShutdown);
  147.     CheckItem(gOptionsMenu, kShutdownOnly, !gOnRestart && gOnShutdown);
  148.     CheckItem(gOptionsMenu, kRestartAndShutdown, gOnRestart && gOnShutdown);
  149.     CheckItem(gOptionsMenu, kNever, !gOnRestart && !gOnShutdown);
  150.     CheckItem(gOptionsMenu, kPickRandom, gChooseRandom);
  151.     CheckItem(gOptionsMenu, kPickSequential, !gChooseRandom);
  152.     CheckItem(gOptionsMenu, kFadeEarly, gFadeEarly);
  153.     CheckItem(gOptionsMenu, kFadeLate, !gFadeEarly);
  154. }
  155.  
  156. void HandleMenu(long mSelect)
  157. {
  158.     short            menuID = HiWord(mSelect);
  159.     short            menuItem = LoWord(mSelect);
  160.     
  161.     switch (menuID)
  162.     {
  163.         case appleMenu:
  164.             HandleAppleMenu(menuItem);
  165.             break;
  166.         case fileMenu:
  167.             HandleFileMenu(menuItem);
  168.             break;    
  169.         case editMenu:
  170.             HandleEditMenu(menuItem);
  171.             break;
  172.         case optionsMenu:
  173.             HandleOptionsMenu(menuItem);
  174.             break;
  175.     }
  176. }
  177.  
  178. void DoTheCloseThing(WindowPeek theWindow)
  179. /* a standard close procedure, called when "close" is chosen from File menu and when
  180.    a window is closed through its close box */
  181. {
  182.     Boolean            gotone;
  183.     short            i;
  184.     short            kind;
  185.     
  186.     if (theWindow==0L)
  187.         return;
  188.     
  189.     kind = theWindow ? theWindow->windowKind : 0;
  190.     if (kind<0)        /* DA window or other system window */
  191.         CloseDeskAcc(kind);
  192.     else
  193.     {
  194.         gotone=FALSE;
  195.         /* see if it's one of ours */
  196.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  197.             gotone=((WindowPtr)theWindow==GetIndWindowGrafPtr(i));
  198.         
  199.         if (gotone)        /* if it's one of ours...  see graphics.c */
  200.             CloseTheIndWindow(i-1);            /* this may return FALSE = not closed */
  201.         else
  202.             DisposeWindow((WindowPtr)theWindow);    /* not one of ours, so just close it */
  203.     
  204.         AdjustMenus();    /* may affect which menu items or menus are available, etc */
  205.     }
  206. }
  207.  
  208. void HandleAppleMenu(short menuItem)
  209. {
  210.     GrafPtr        savePort;
  211.     Str255        name;
  212.     
  213.     switch (menuItem)
  214.     {
  215.         case aboutItem:
  216.             OpenTheIndWindow(kAbout);
  217.             break;
  218.         case aboutMSGItem:
  219.             OpenTheIndWindow(kAboutMSG);
  220.             break;
  221.         case helpPointerItem:
  222.             HandleHelpMenu();
  223.             break;
  224.         default:
  225.             if (menuItem > helpPointerItem+1)
  226.             {
  227.                 GetPort(&savePort);
  228.                 GetItem(gAppleMenu, menuItem, name);
  229.                 OpenDeskAcc(name);
  230.                 SetPort(savePort);
  231.             }
  232.             break;
  233.     }
  234. }
  235.  
  236. void HandleFileMenu(short menuItem)
  237. {
  238.     WindowPtr            theWindow;
  239.     short                i;
  240.     Boolean                gotone;
  241.     
  242.     switch (menuItem)
  243.     {
  244.         case openItem:
  245.             OpenTheIndWindow(kMainWindow);
  246.             break;
  247.         case closeItem:
  248.             DoTheCloseThing((WindowPeek)FrontWindow());
  249.             break;
  250.         case deBinHexItem:
  251.             if (GetSourceFile(&inputFS, TRUE, FALSE))
  252.             {
  253.                 SetErrorParameters("\pFile: ", inputFS.name, "\p");
  254.                 HandleError(DeBinHexDispatch(), FALSE, TRUE);
  255.             }
  256.             break;
  257.         case quitItem:
  258.             gDone = TRUE;
  259.             break;
  260.     }
  261. }
  262.  
  263. void HandleEditMenu(short menuItem)
  264. {
  265.     if (gFrontWindowIsOurs)
  266.     {
  267.         switch (menuItem)
  268.         {
  269.             case undoItem:        CallIndDispatchProc(gFrontWindowIndex, kUndo, 0L);    break;
  270.             case cutItem:        CallIndDispatchProc(gFrontWindowIndex, kCut, 0L);    break;
  271.             case copyItem:        CallIndDispatchProc(gFrontWindowIndex, kCopy, 0L);    break;
  272.             case pasteItem:        CallIndDispatchProc(gFrontWindowIndex, kPaste, 0L);    break;
  273.             case clearItem:        CallIndDispatchProc(gFrontWindowIndex, kClear, 0L);    break;
  274.             case selectAllItem:    CallIndDispatchProc(gFrontWindowIndex, kSelectAll, 0L);    break;
  275.         }
  276.     }
  277.     else SystemEdit(menuItem-1);
  278. }
  279.  
  280. void HandleHelpMenu(void)
  281. {
  282.     OpenTheIndWindow(kHelp);
  283. }
  284.  
  285. void HandleOptionsMenu(short menuItem)
  286. {
  287.     switch (menuItem)
  288.     {
  289.         case kRestartOnly:
  290.             gOnRestart=TRUE;
  291.             gOnShutdown=FALSE;
  292.             break;
  293.         case kShutdownOnly:
  294.             gOnRestart=FALSE;
  295.             gOnShutdown=TRUE;
  296.             break;
  297.         case kRestartAndShutdown:
  298.             gOnRestart=gOnShutdown=TRUE;
  299.             break;
  300.         case kNever:
  301.             gOnRestart=gOnShutdown=FALSE;
  302.             break;
  303.         case kPickRandom:
  304.             gChooseRandom=TRUE;
  305.             break;
  306.         case kPickSequential:
  307.             gChooseRandom=FALSE;
  308.             break;
  309.         case kFadeEarly:
  310.             gFadeEarly=TRUE;
  311.             ChangeWarning();
  312.             break;
  313.         case kFadeLate:
  314.             gFadeEarly=FALSE;
  315.             ChangeWarning();
  316.             break;
  317.         case kRescanForModules:
  318.             if (!GetIndWindowGrafPtr(kMainWindow))
  319.                 OpenTheIndWindow(kMainWindow);
  320.             else
  321.                 HandleError(MakeNewLists(TRUE), TRUE, FALSE);
  322.             break;
  323.     }
  324. }
  325.  
  326. void ChangeWarning(void)
  327. {
  328.     ParamText("\pThis option will not take effect until you restart your computer.","\p","\p","\p");
  329.     PositionDialog('ALRT', smallAlert);
  330.     NoteAlert(smallAlert, 0L);
  331. }
  332.